/**
 * XL-Payment 微信支付适配器
 */
import { formatAmount, delay } from '../utils';

export default class WechatAdapter {
  constructor() {
    this.name = 'wechat';
    this.title = '微信支付';
  }
  
  /**
   * 发起支付
   * @param {Object} options 支付参数
   * @returns {Promise} 支付结果
   */
  async pay(options) {
    const { order, amount, config, env } = options;
    
    try {
      // 处理不同平台的支付方式
      if (env.isMP && env.platform === 'mp-weixin') {
        // 微信小程序支付
        return await this._mpWeixinPay(order, amount, config);
      } else if (env.isH5) {
        // H5支付
        return await this._h5Pay(order, amount, config);
      } else if (env.isApp) {
        // APP支付
        return await this._appPay(order, amount, config);
      } else {
        throw new Error('当前平台不支持微信支付');
      }
    } catch (error) {
      console.error('微信支付失败:', error);
      return { 
        success: false, 
        message: '支付失败: ' + (error.message || error),
        error
      };
    }
  }
  
  /**
   * 微信小程序支付
   * @param {Object} order 订单信息
   * @param {Number} amount 支付金额
   * @param {Object} config 配置
   * @returns {Promise} 支付结果
   */
  async _mpWeixinPay(order, amount, config) {
    // 获取支付参数
    try {
      // 模拟从服务器获取支付参数
      // 实际项目中，这里应该是向自己的服务器请求支付参数
      const payParams = await this._getPayParams({
        order,
        amount,
        config,
        tradeType: 'JSAPI'
      });
      
      if (!payParams || !payParams.success) {
        throw new Error(payParams?.message || '获取支付参数失败');
      }
      
      // 发起小程序支付
      return new Promise((resolve, reject) => {
        uni.requestPayment({
          provider: 'wxpay',
          timeStamp: payParams.timeStamp,
          nonceStr: payParams.nonceStr,
          package: payParams.package,
          signType: payParams.signType,
          paySign: payParams.paySign,
          success: result => {
            resolve({
              success: true,
              order,
              result,
              paymentType: 'wechat',
              message: '支付成功'
            });
          },
          fail: error => {
            // 用户取消不算失败
            if (error.errMsg && error.errMsg.indexOf('cancel') > -1) {
              resolve({
                success: false,
                canceled: true,
                order,
                message: '用户取消支付'
              });
            } else {
              reject(error);
            }
          }
        });
      });
    } catch (error) {
      console.error('微信小程序支付失败:', error);
      return { 
        success: false, 
        message: '支付失败: ' + (error.message || error),
        error
      };
    }
  }
  
  /**
   * H5支付
   * @param {Object} order 订单信息
   * @param {Number} amount 支付金额
   * @param {Object} config 配置
   * @returns {Promise} 支付结果
   */
  async _h5Pay(order, amount, config) {
    // 获取H5支付参数
    try {
      // 模拟从服务器获取支付参数
      const payParams = await this._getPayParams({
        order,
        amount,
        config,
        tradeType: 'MWEB'
      });
      
      if (!payParams || !payParams.success) {
        throw new Error(payParams?.message || '获取支付参数失败');
      }
      
      // 跳转到微信支付页面
      if (payParams.mwebUrl) {
        // 记录支付状态
        uni.setStorageSync(`wx_paying_${order.id}`, JSON.stringify({
          timestamp: Date.now(),
          returnUrl: payParams.returnUrl || location.href
        }));
        
        // 跳转到微信支付
        location.href = payParams.mwebUrl;
        
        // H5支付是重定向，这里直接返回进行中状态
        return {
          success: true,
          pending: true,
          order,
          paymentType: 'wechat',
          message: '已跳转到微信支付'
        };
      } else {
        throw new Error('未获取到支付链接');
      }
    } catch (error) {
      console.error('微信H5支付失败:', error);
      return { 
        success: false, 
        message: '支付失败: ' + (error.message || error),
        error
      };
    }
  }
  
  /**
   * APP支付
   * @param {Object} order 订单信息
   * @param {Number} amount 支付金额
   * @param {Object} config 配置
   * @returns {Promise} 支付结果
   */
  async _appPay(order, amount, config) {
    // 获取APP支付参数
    try {
      // 模拟从服务器获取支付参数
      const payParams = await this._getPayParams({
        order,
        amount,
        config,
        tradeType: 'APP'
      });
      
      if (!payParams || !payParams.success) {
        throw new Error(payParams?.message || '获取支付参数失败');
      }
      
      // 调用APP支付
      return new Promise((resolve, reject) => {
        uni.requestPayment({
          provider: 'wxpay',
          orderInfo: payParams,
          success: result => {
            resolve({
              success: true,
              order,
              result,
              paymentType: 'wechat',
              message: '支付成功'
            });
          },
          fail: error => {
            // 用户取消不算失败
            if (error.errMsg && error.errMsg.indexOf('cancel') > -1) {
              resolve({
                success: false,
                canceled: true,
                order,
                message: '用户取消支付'
              });
            } else {
              reject(error);
            }
          }
        });
      });
    } catch (error) {
      console.error('微信APP支付失败:', error);
      return { 
        success: false, 
        message: '支付失败: ' + (error.message || error),
        error
      };
    }
  }
  
  /**
   * 获取支付参数
   * @param {Object} options 请求参数
   * @returns {Promise} 支付参数
   */
  async _getPayParams(options) {
    const { order, amount, config, tradeType } = options;
    
    // 实际项目中，这里应该向服务端请求支付参数
    // 这里为了演示，模拟返回格式
    
    // 模拟网络请求
    await delay(500);
    
    // 模拟不同类型的支付参数
    if (tradeType === 'JSAPI') {
      // 小程序支付参数
      return {
        success: true,
        timeStamp: '' + Math.floor(Date.now() / 1000),
        nonceStr: 'mock_nonce_' + Math.random().toString(36).substr(2, 15),
        package: 'prepay_id=wx' + Date.now(),
        signType: 'MD5',
        paySign: 'mock_sign_' + Math.random().toString(36).substr(2, 15)
      };
    } else if (tradeType === 'MWEB') {
      // H5支付参数
      return {
        success: true,
        mwebUrl: `https://wx.tenpay.com/cgi-bin/mmpayweb-bin/checkmweb?prepay_id=wx${Date.now()}&package=1234567890`,
        returnUrl: options.returnUrl || ''
      };
    } else if (tradeType === 'APP') {
      // APP支付参数
      return {
        success: true,
        appid: config.appId || 'mock_appid',
        partnerid: config.mchId || 'mock_partnerid',
        prepayid: 'wx' + Date.now(),
        package: 'Sign=WXPay',
        noncestr: 'mock_nonce_' + Math.random().toString(36).substr(2, 15),
        timestamp: '' + Math.floor(Date.now() / 1000),
        sign: 'mock_sign_' + Math.random().toString(36).substr(2, 15)
      };
    }
    
    return { success: false, message: '不支持的交易类型' };
  }
  
  /**
   * 查询订单
   * @param {Object} options 查询参数
   * @returns {Promise} 查询结果
   */
  async queryOrder(options) {
    const { order, config } = options;
    
    try {
      // 实际项目中，这里应该向服务端请求查询订单状态
      await delay(500);
      
      // 模拟订单查询结果
      const mockResults = [
        { status: 'CREATED', message: '订单未支付' },
        { status: 'PAYING', message: '正在支付中' },
        { status: 'PAID', message: '支付成功', paidAt: new Date().toISOString() },
        { status: 'FAILED', message: '支付失败', closedAt: new Date().toISOString() },
      ];
      
      // 随机返回一个模拟状态
      const randomStatus = mockResults[Math.floor(Math.random() * mockResults.length)];
      
      return {
        success: true,
        ...randomStatus,
        orderId: order.id,
        paymentType: 'wechat'
      };
    } catch (error) {
      console.error('查询微信订单失败:', error);
      return { 
        success: false,
        message: '查询订单失败: ' + (error.message || error),
        error,
        orderId: order.id
      };
    }
  }
  
  /**
   * 关闭订单
   * @param {Object} options 关闭参数
   * @returns {Promise} 关闭结果
   */
  async closeOrder(options) {
    const { order, config } = options;
    
    try {
      // 实际项目中，这里应该向服务端请求关闭订单
      await delay(300);
      
      // 模拟关闭成功
      return {
        success: true,
        message: '订单已关闭',
        orderId: order.id,
        paymentType: 'wechat'
      };
    } catch (error) {
      console.error('关闭微信订单失败:', error);
      return { 
        success: false,
        message: '关闭订单失败: ' + (error.message || error),
        error,
        orderId: order.id
      };
    }
  }
  
  /**
   * 申请退款
   * @param {Object} options 退款参数
   * @returns {Promise} 退款结果
   */
  async refund(options) {
    const { order, amount, reason, config } = options;
    
    try {
      // 实际项目中，这里应该向服务端请求退款
      await delay(700);
      
      // 模拟退款成功
      return {
        success: true,
        message: '退款申请成功',
        refundId: 'wx_refund_' + Date.now(),
        orderId: order.id,
        amount: amount,
        paymentType: 'wechat'
      };
    } catch (error) {
      console.error('微信退款失败:', error);
      return { 
        success: false,
        message: '申请退款失败: ' + (error.message || error),
        error,
        orderId: order.id
      };
    }
  }
} 